﻿namespace Sidvall.IdentityManager.UI.Entities
{
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling")]
    public sealed partial class AspNetUsers : global::Sidvall.IdentityManager.UI.Entities.Core.BusinessBase, global::Sidvall.IdentityManager.Data.IAspNetUsers
    {
        #region Business Members

        #region AccessFailedCount

        private int _AccessFailedCount = 0;
        partial void OnBeforeAccessFailedCountPropertyGet(Sidvall.Business.PropertyEventData<int> eventData);
        partial void OnBeforeAccessFailedCountPropertyChanged(Sidvall.Business.PropertyChangeEventData<int> eventData);
        partial void OnAfterAccessFailedCountPropertyChanged();
        public int AccessFailedCount
        {
            get
            {
                Sidvall.Business.PropertyEventData<int> eventData = new Sidvall.Business.PropertyEventData<int>(_AccessFailedCount);
                OnBeforeAccessFailedCountPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<int> eventData = new Sidvall.Business.PropertyChangeEventData<int>(value, _AccessFailedCount);
                OnBeforeAccessFailedCountPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("AccessFailedCount", eventData.Value, true, true, true);
                    OnAfterAccessFailedCountPropertyChanged();
                }
            }
        }

        #endregion
        #region Email

        private string _Email = null;
        partial void OnBeforeEmailPropertyGet(Sidvall.Business.PropertyEventData<string> eventData);
        partial void OnBeforeEmailPropertyChanged(Sidvall.Business.PropertyChangeEventData<string> eventData);
        partial void OnAfterEmailPropertyChanged();
        public string Email
        {
            get
            {
                Sidvall.Business.PropertyEventData<string> eventData = new Sidvall.Business.PropertyEventData<string>(_Email);
                OnBeforeEmailPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<string> eventData = new Sidvall.Business.PropertyChangeEventData<string>(value, _Email);
                OnBeforeEmailPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("Email", eventData.Value, true, true, true);
                    OnAfterEmailPropertyChanged();
                }
            }
        }

        #endregion
        #region EmailConfirmed

        private bool _EmailConfirmed = false;
        partial void OnBeforeEmailConfirmedPropertyGet(Sidvall.Business.PropertyEventData<bool> eventData);
        partial void OnBeforeEmailConfirmedPropertyChanged(Sidvall.Business.PropertyChangeEventData<bool> eventData);
        partial void OnAfterEmailConfirmedPropertyChanged();
        public bool EmailConfirmed
        {
            get
            {
                Sidvall.Business.PropertyEventData<bool> eventData = new Sidvall.Business.PropertyEventData<bool>(_EmailConfirmed);
                OnBeforeEmailConfirmedPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<bool> eventData = new Sidvall.Business.PropertyChangeEventData<bool>(value, _EmailConfirmed);
                OnBeforeEmailConfirmedPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("EmailConfirmed", eventData.Value, true, true, true);
                    OnAfterEmailConfirmedPropertyChanged();
                }
            }
        }

        #endregion
        #region Id

        private string _Id = null;
        partial void OnBeforeIdPropertyGet(Sidvall.Business.PropertyEventData<string> eventData);
        partial void OnBeforeIdPropertyChanged(Sidvall.Business.PropertyChangeEventData<string> eventData);
        partial void OnAfterIdPropertyChanged();
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public string Id
        {
            get
            {
                Sidvall.Business.PropertyEventData<string> eventData = new Sidvall.Business.PropertyEventData<string>(_Id);
                OnBeforeIdPropertyGet(eventData);
                return eventData.Value;
            }
            internal set
            {
                Sidvall.Business.PropertyChangeEventData<string> eventData = new Sidvall.Business.PropertyChangeEventData<string>(value, _Id);
                OnBeforeIdPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("Id", eventData.Value, true, true, true);
                    OnAfterIdPropertyChanged();
                }
            }
        }

        #endregion
        #region LockoutEnabled

        private bool _LockoutEnabled = false;
        partial void OnBeforeLockoutEnabledPropertyGet(Sidvall.Business.PropertyEventData<bool> eventData);
        partial void OnBeforeLockoutEnabledPropertyChanged(Sidvall.Business.PropertyChangeEventData<bool> eventData);
        partial void OnAfterLockoutEnabledPropertyChanged();
        public bool LockoutEnabled
        {
            get
            {
                Sidvall.Business.PropertyEventData<bool> eventData = new Sidvall.Business.PropertyEventData<bool>(_LockoutEnabled);
                OnBeforeLockoutEnabledPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<bool> eventData = new Sidvall.Business.PropertyChangeEventData<bool>(value, _LockoutEnabled);
                OnBeforeLockoutEnabledPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("LockoutEnabled", eventData.Value, true, true, true);
                    OnAfterLockoutEnabledPropertyChanged();
                }
            }
        }

        #endregion
        #region LockoutEndDateUtc

        private System.Nullable<System.DateTime> _LockoutEndDateUtc = null;
        partial void OnBeforeLockoutEndDateUtcPropertyGet(Sidvall.Business.PropertyEventData<System.Nullable<System.DateTime>> eventData);
        partial void OnBeforeLockoutEndDateUtcPropertyChanged(Sidvall.Business.PropertyChangeEventData<System.Nullable<System.DateTime>> eventData);
        partial void OnAfterLockoutEndDateUtcPropertyChanged();
        public System.Nullable<System.DateTime> LockoutEndDateUtc
        {
            get
            {
                Sidvall.Business.PropertyEventData<System.Nullable<System.DateTime>> eventData = new Sidvall.Business.PropertyEventData<System.Nullable<System.DateTime>>(Sidvall.Business.ValidationManager.GetValidDateTime(_LockoutEndDateUtc));
                OnBeforeLockoutEndDateUtcPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<System.Nullable<System.DateTime>> eventData = new Sidvall.Business.PropertyChangeEventData<System.Nullable<System.DateTime>>(value, _LockoutEndDateUtc);
                OnBeforeLockoutEndDateUtcPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("LockoutEndDateUtc", eventData.Value, true, true, true);
                    OnAfterLockoutEndDateUtcPropertyChanged();
                }
            }
        }

        #endregion
        #region PasswordHash

        private string _PasswordHash = null;
        partial void OnBeforePasswordHashPropertyGet(Sidvall.Business.PropertyEventData<string> eventData);
        partial void OnBeforePasswordHashPropertyChanged(Sidvall.Business.PropertyChangeEventData<string> eventData);
        partial void OnAfterPasswordHashPropertyChanged();
        public string PasswordHash
        {
            get
            {
                Sidvall.Business.PropertyEventData<string> eventData = new Sidvall.Business.PropertyEventData<string>(_PasswordHash);
                OnBeforePasswordHashPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<string> eventData = new Sidvall.Business.PropertyChangeEventData<string>(value, _PasswordHash);
                OnBeforePasswordHashPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("PasswordHash", eventData.Value, true, true, true);
                    OnAfterPasswordHashPropertyChanged();
                }
            }
        }

        #endregion
        #region PhoneNumber

        private string _PhoneNumber = null;
        partial void OnBeforePhoneNumberPropertyGet(Sidvall.Business.PropertyEventData<string> eventData);
        partial void OnBeforePhoneNumberPropertyChanged(Sidvall.Business.PropertyChangeEventData<string> eventData);
        partial void OnAfterPhoneNumberPropertyChanged();
        public string PhoneNumber
        {
            get
            {
                Sidvall.Business.PropertyEventData<string> eventData = new Sidvall.Business.PropertyEventData<string>(_PhoneNumber);
                OnBeforePhoneNumberPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<string> eventData = new Sidvall.Business.PropertyChangeEventData<string>(value, _PhoneNumber);
                OnBeforePhoneNumberPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("PhoneNumber", eventData.Value, true, true, true);
                    OnAfterPhoneNumberPropertyChanged();
                }
            }
        }

        #endregion
        #region PhoneNumberConfirmed

        private bool _PhoneNumberConfirmed = false;
        partial void OnBeforePhoneNumberConfirmedPropertyGet(Sidvall.Business.PropertyEventData<bool> eventData);
        partial void OnBeforePhoneNumberConfirmedPropertyChanged(Sidvall.Business.PropertyChangeEventData<bool> eventData);
        partial void OnAfterPhoneNumberConfirmedPropertyChanged();
        public bool PhoneNumberConfirmed
        {
            get
            {
                Sidvall.Business.PropertyEventData<bool> eventData = new Sidvall.Business.PropertyEventData<bool>(_PhoneNumberConfirmed);
                OnBeforePhoneNumberConfirmedPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<bool> eventData = new Sidvall.Business.PropertyChangeEventData<bool>(value, _PhoneNumberConfirmed);
                OnBeforePhoneNumberConfirmedPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("PhoneNumberConfirmed", eventData.Value, true, true, true);
                    OnAfterPhoneNumberConfirmedPropertyChanged();
                }
            }
        }

        #endregion
        #region SecurityStamp

        private string _SecurityStamp = null;
        partial void OnBeforeSecurityStampPropertyGet(Sidvall.Business.PropertyEventData<string> eventData);
        partial void OnBeforeSecurityStampPropertyChanged(Sidvall.Business.PropertyChangeEventData<string> eventData);
        partial void OnAfterSecurityStampPropertyChanged();
        public string SecurityStamp
        {
            get
            {
                Sidvall.Business.PropertyEventData<string> eventData = new Sidvall.Business.PropertyEventData<string>(_SecurityStamp);
                OnBeforeSecurityStampPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<string> eventData = new Sidvall.Business.PropertyChangeEventData<string>(value, _SecurityStamp);
                OnBeforeSecurityStampPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("SecurityStamp", eventData.Value, true, true, true);
                    OnAfterSecurityStampPropertyChanged();
                }
            }
        }

        #endregion
        #region TwoFactorEnabled

        private bool _TwoFactorEnabled = false;
        partial void OnBeforeTwoFactorEnabledPropertyGet(Sidvall.Business.PropertyEventData<bool> eventData);
        partial void OnBeforeTwoFactorEnabledPropertyChanged(Sidvall.Business.PropertyChangeEventData<bool> eventData);
        partial void OnAfterTwoFactorEnabledPropertyChanged();
        public bool TwoFactorEnabled
        {
            get
            {
                Sidvall.Business.PropertyEventData<bool> eventData = new Sidvall.Business.PropertyEventData<bool>(_TwoFactorEnabled);
                OnBeforeTwoFactorEnabledPropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<bool> eventData = new Sidvall.Business.PropertyChangeEventData<bool>(value, _TwoFactorEnabled);
                OnBeforeTwoFactorEnabledPropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("TwoFactorEnabled", eventData.Value, true, true, true);
                    OnAfterTwoFactorEnabledPropertyChanged();
                }
            }
        }

        #endregion
        #region UserName

        private string _UserName = string.Empty;
        partial void OnBeforeUserNamePropertyGet(Sidvall.Business.PropertyEventData<string> eventData);
        partial void OnBeforeUserNamePropertyChanged(Sidvall.Business.PropertyChangeEventData<string> eventData);
        partial void OnAfterUserNamePropertyChanged();
        public string UserName
        {
            get
            {
                Sidvall.Business.PropertyEventData<string> eventData = new Sidvall.Business.PropertyEventData<string>(_UserName);
                OnBeforeUserNamePropertyGet(eventData);
                return eventData.Value;
            }
            set
            {
                Sidvall.Business.PropertyChangeEventData<string> eventData = new Sidvall.Business.PropertyChangeEventData<string>(value, _UserName);
                OnBeforeUserNamePropertyChanged(eventData);
                if (!eventData.Cancel)
                {
                    LoadInstanceField("UserName", eventData.Value, true, true, true);
                    OnAfterUserNamePropertyChanged();
                }
            }
        }

        #endregion
        #region AspNetRoles

        private AspNetRolesCollection _AspNetRoles;
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public AspNetRolesCollection AspNetRoles
        {
            get
            {
                return _AspNetRoles;
            }
            internal set
            {
                LoadInstanceField("AspNetRoles", value, true, false, false);
            }
        }

        #endregion
        #region AspNetUserClaims

        private AspNetUserClaimsCollection _AspNetUserClaims;
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public AspNetUserClaimsCollection AspNetUserClaims
        {
            get
            {
                return _AspNetUserClaims;
            }
            internal set
            {
                LoadInstanceField("AspNetUserClaims", value, true, false, false);
            }
        }

        #endregion
        #region AspNetUserLogins

        private AspNetUserLoginsCollection _AspNetUserLogins;
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        public AspNetUserLoginsCollection AspNetUserLogins
        {
            get
            {
                return _AspNetUserLogins;
            }
            internal set
            {
                LoadInstanceField("AspNetUserLogins", value, true, false, false);
            }
        }

        #endregion
        #region DataRowContextStorageKey

        protected override string DataRowContextStorageKey
        {
            get
            {
                return global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.GetKey(this);
            }
        }

        #endregion
        #region DataRowIsValid

        public override bool DataRowIsValid(Sidvall.Data.BusinessRuleFilter filter)
        {
            return global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.DataRowIsValid(this, filter);
        }

        #endregion
        #region DataRowStateIsDirty

        public override bool DataRowStateIsDirty
        {
            get
            {
                return global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.DataRowStateIsDirty(this);
            }
        }

        #endregion

        #region LoadAspNetUserClaims

        public void LoadAspNetUserClaims(AspNetUserClaimsCollection value)
        {
            LoadInstanceField("AspNetUserClaims", value, true, true, false);
        }

        #endregion
        #region LoadAspNetUserLogins

        public void LoadAspNetUserLogins(AspNetUserLoginsCollection value)
        {
            LoadInstanceField("AspNetUserLogins", value, true, true, false);
        }

        #endregion
        #region LoadAspNetUserClaimsAsync

        public async System.Threading.Tasks.Task<AspNetUserClaimsCollection> LoadAspNetUserClaimsAsync()
        {
            return await LoadAspNetUserClaimsAsync(false, true, null, null, null);
        }
        public async System.Threading.Tasks.Task<AspNetUserClaimsCollection> LoadAspNetUserClaimsAsync(bool refresh, bool raisePropertyChanged, global::Sidvall.Data.FetchListCriteria<global::Sidvall.IdentityManager.Data.Fields.AspNetUserClaimsField, global::Sidvall.IdentityManager.Data.Relations.AspNetUserClaimsRelation> criteria, string strategyContext, global::Sidvall.Data.ObjectParameterCollection objectParameters)
        {
            await global::Sidvall.IdentityManager.UI.SystemContext.Current.DataPortal.AspNetUsersManager.LoadAspNetUserClaimsAsync(this, refresh, raisePropertyChanged, criteria, strategyContext, objectParameters);

            return this.AspNetUserClaims;
        }

        #endregion
        #region LoadAspNetUserLoginsAsync

        public async System.Threading.Tasks.Task<AspNetUserLoginsCollection> LoadAspNetUserLoginsAsync()
        {
            return await LoadAspNetUserLoginsAsync(false, true, null, null, null);
        }
        public async System.Threading.Tasks.Task<AspNetUserLoginsCollection> LoadAspNetUserLoginsAsync(bool refresh, bool raisePropertyChanged, global::Sidvall.Data.FetchListCriteria<global::Sidvall.IdentityManager.Data.Fields.AspNetUserLoginsField, global::Sidvall.IdentityManager.Data.Relations.AspNetUserLoginsRelation> criteria, string strategyContext, global::Sidvall.Data.ObjectParameterCollection objectParameters)
        {
            await global::Sidvall.IdentityManager.UI.SystemContext.Current.DataPortal.AspNetUsersManager.LoadAspNetUserLoginsAsync(this, refresh, raisePropertyChanged, criteria, strategyContext, objectParameters);

            return this.AspNetUserLogins;
        }

        #endregion
        #region LoadInstanceField

        public void LoadInstanceField(string fieldName, object value, bool cascade, bool raisePropertyChanged, bool updateState)
        {
            global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.LoadInstanceField(this, fieldName, value, cascade, raisePropertyChanged, updateState);
        }

        #endregion
        #region AcceptChanges

        public void AcceptChanges()
        {
            global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.AcceptChanges(this);
        }

        #endregion
        #region Clone

        public AspNetUsers Clone()
        {
            var copySettings = Sidvall.Data.CopySettings.Clone();
            return Copy(copySettings);
        }

        #endregion
        #region Copy

        public AspNetUsers Copy()
        {
            return Copy(null);
        }
        public AspNetUsers Copy(Sidvall.Data.CopySettings copySettings)
        {
            if (copySettings == null)
                copySettings = new Sidvall.Data.CopySettings();
            if (!Sidvall.Data.DataRowContextManager.IsValid(this, copySettings.RowFilter))
                return null;
            var item = new AspNetUsers();
            Import(item, this, copySettings);
            return item;
        }

        #endregion
        #region Import

        public void Import(global::Sidvall.IdentityManager.Data.IAspNetUsers item)
        {
            Import(item, null);
        }
        public void Import(global::Sidvall.IdentityManager.Data.IAspNetUsers item, Sidvall.Data.CopySettings copySettings)
        {
            Import(this, item, copySettings);
        }
        partial void OnAfterImport(AspNetUsers destination, global::Sidvall.IdentityManager.Data.IAspNetUsers source, Sidvall.Data.CopySettings copySettings);
        private void Import(AspNetUsers destination, global::Sidvall.IdentityManager.Data.IAspNetUsers source, Sidvall.Data.CopySettings copySettings)
        {
            global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.Import(destination, source, copySettings);
            OnAfterImport(destination, source, copySettings);
        }
        partial void OnAfterImport(AspNetUsers destination, AspNetUsers source, Sidvall.Data.CopySettings copySettings);
        private void Import(AspNetUsers destination, AspNetUsers source, Sidvall.Data.CopySettings copySettings)
        {
            Import(destination, source as global::Sidvall.IdentityManager.Data.IAspNetUsers, copySettings);
            OnAfterImport(destination, source, copySettings);
        }

        #endregion
        #region SaveItemAsync

        public async System.Threading.Tasks.Task<AspNetUsers> SaveItemAsync()
        {
            return await global::Sidvall.IdentityManager.UI.SystemContext.Current.DataPortal.AspNetUsersManager.SaveItemAsync(this);
        }
        public async System.Threading.Tasks.Task<AspNetUsers> SaveItemAsync(Sidvall.Data.SaveMode mode)
        {
            return await global::Sidvall.IdentityManager.UI.SystemContext.Current.DataPortal.AspNetUsersManager.SaveItemAsync(this, mode);
        }
        public async System.Threading.Tasks.Task<AspNetUsers> SaveItemAsync(Sidvall.Data.SaveSettings settings)
        {
            return await global::Sidvall.IdentityManager.UI.SystemContext.Current.DataPortal.AspNetUsersManager.SaveItemAsync(this, settings);
        }
        public async System.Threading.Tasks.Task<AspNetUsers> SaveItemAsync(Sidvall.Data.SaveSettings settings, string strategyContext, global::Sidvall.Data.ObjectParameterCollection objectParameters)
        {
            return await global::Sidvall.IdentityManager.UI.SystemContext.Current.DataPortal.AspNetUsersManager.SaveItemAsync(this, settings, strategyContext, objectParameters);
        }

        #endregion
        #region ValidateAsync

        public async System.Threading.Tasks.Task<Sidvall.Data.BusinessRuleCollection> ValidateAsync()
        {
            return await ValidateAsync((Sidvall.Data.ValidationSettings)null);
        }
        public async System.Threading.Tasks.Task<Sidvall.Data.BusinessRuleCollection> ValidateAsync(Sidvall.Data.ValidationSettings settings)
        {
            var context = new Sidvall.Business.ValidationContext(settings);
            await global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.ValidateAsync(this, context);
            await ValidateAsync(context);
            return context.AllBusinessRules;
        }
        partial void OnAfterValidate(Sidvall.Data.BusinessRuleCollection itemBusinessRules, Sidvall.Business.ValidationContext context);
        public async System.Threading.Tasks.Task ValidateAsync(Sidvall.Business.ValidationContext context)
        {
            var itemBusinessRules = new Sidvall.Data.BusinessRuleCollection();
            OnAfterValidate(itemBusinessRules, context);
            await context.TaskContext.DoTaskAsync();
            context.AllBusinessRules.AddRange(context.Settings.IncludeNotBrokenRules, itemBusinessRules);
            var businessRulesProvider = this as Sidvall.Data.IBusinessRulesProvider;
            if (businessRulesProvider != null)
                businessRulesProvider.BusinessRules.AddRange(context.Settings.IncludeNotBrokenRules, itemBusinessRules);
        }

        #endregion
        #region Initialize

        public void Initialize()
        {
            global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.Initialize(this);
        }
        public void Initialize(Sidvall.Data.InitializeSettings settings)
        {
            global::Sidvall.IdentityManager.UI.SystemContext.Current.EntityFacade.AspNetUsersManager.Initialize(this, settings);
        }

        #endregion
        
        #region IAspNetUsers Members

        int global::Sidvall.IdentityManager.Data.IAspNetUsers.AccessFailedCount
        {
            get
            {
                return this._AccessFailedCount;
            }
            set
            {
                this._AccessFailedCount = value;
            }
        }
        string global::Sidvall.IdentityManager.Data.IAspNetUsers.Email
        {
            get
            {
                return this._Email;
            }
            set
            {
                this._Email = value;
            }
        }
        bool global::Sidvall.IdentityManager.Data.IAspNetUsers.EmailConfirmed
        {
            get
            {
                return this._EmailConfirmed;
            }
            set
            {
                this._EmailConfirmed = value;
            }
        }
        string global::Sidvall.IdentityManager.Data.IAspNetUsers.Id
        {
            get
            {
                return this._Id;
            }
            set
            {
                this._Id = value;
            }
        }
        bool global::Sidvall.IdentityManager.Data.IAspNetUsers.LockoutEnabled
        {
            get
            {
                return this._LockoutEnabled;
            }
            set
            {
                this._LockoutEnabled = value;
            }
        }
        System.Nullable<System.DateTime> global::Sidvall.IdentityManager.Data.IAspNetUsers.LockoutEndDateUtc
        {
            get
            {
                return this._LockoutEndDateUtc;
            }
            set
            {
                this._LockoutEndDateUtc = value;
            }
        }
        string global::Sidvall.IdentityManager.Data.IAspNetUsers.PasswordHash
        {
            get
            {
                return this._PasswordHash;
            }
            set
            {
                this._PasswordHash = value;
            }
        }
        string global::Sidvall.IdentityManager.Data.IAspNetUsers.PhoneNumber
        {
            get
            {
                return this._PhoneNumber;
            }
            set
            {
                this._PhoneNumber = value;
            }
        }
        bool global::Sidvall.IdentityManager.Data.IAspNetUsers.PhoneNumberConfirmed
        {
            get
            {
                return this._PhoneNumberConfirmed;
            }
            set
            {
                this._PhoneNumberConfirmed = value;
            }
        }
        string global::Sidvall.IdentityManager.Data.IAspNetUsers.SecurityStamp
        {
            get
            {
                return this._SecurityStamp;
            }
            set
            {
                this._SecurityStamp = value;
            }
        }
        bool global::Sidvall.IdentityManager.Data.IAspNetUsers.TwoFactorEnabled
        {
            get
            {
                return this._TwoFactorEnabled;
            }
            set
            {
                this._TwoFactorEnabled = value;
            }
        }
        string global::Sidvall.IdentityManager.Data.IAspNetUsers.UserName
        {
            get
            {
                return this._UserName;
            }
            set
            {
                this._UserName = value;
            }
        }
        System.Collections.Generic.IEnumerable<global::Sidvall.IdentityManager.Data.IAspNetRoles> global::Sidvall.IdentityManager.Data.IAspNetUsers.AspNetRoles
        {
            get
            {
                return this._AspNetRoles;
            }
        }
        void global::Sidvall.IdentityManager.Data.IAspNetUsers.SetAspNetRoles(Sidvall.Data.IDataRowProvider<global::Sidvall.IdentityManager.Data.IAspNetRoles> items)
        {
            UpdateChildProperty(this._AspNetRoles, items);
            this._AspNetRoles = items as AspNetRolesCollection;
        }
        System.Collections.Generic.IEnumerable<global::Sidvall.IdentityManager.Data.IAspNetUserClaims> global::Sidvall.IdentityManager.Data.IAspNetUsers.AspNetUserClaims
        {
            get
            {
                return this._AspNetUserClaims;
            }
        }
        void global::Sidvall.IdentityManager.Data.IAspNetUsers.SetAspNetUserClaims(Sidvall.Data.IDataRowProvider<global::Sidvall.IdentityManager.Data.IAspNetUserClaims> items)
        {
            UpdateChildProperty(this._AspNetUserClaims, items);
            this._AspNetUserClaims = items as AspNetUserClaimsCollection;
        }
        System.Collections.Generic.IEnumerable<global::Sidvall.IdentityManager.Data.IAspNetUserLogins> global::Sidvall.IdentityManager.Data.IAspNetUsers.AspNetUserLogins
        {
            get
            {
                return this._AspNetUserLogins;
            }
        }
        void global::Sidvall.IdentityManager.Data.IAspNetUsers.SetAspNetUserLogins(Sidvall.Data.IDataRowProvider<global::Sidvall.IdentityManager.Data.IAspNetUserLogins> items)
        {
            UpdateChildProperty(this._AspNetUserLogins, items);
            this._AspNetUserLogins = items as AspNetUserLoginsCollection;
        }

        #endregion

        #endregion
        #region Constructors

        public AspNetUsers()
        {
        }

        public AspNetUsers(Sidvall.Data.DataRowState? dataRowState)
            : base(dataRowState)
        {
        }

        #endregion
    }
}